Java Interface

In Java, an interface is a means for achieving abstraction. The Java interface can only have abstract methods, not method bodies. In Java, it is used to achieve abstraction and multiple inheritance.

The interface is the blueprint of a class which contains only abstract method(s).

Interface cannot be instantiated like abstract class, but it can contain instance of the class that implemented it.

Syntax for interface

interface <interface_name>{  
      
    // constant fields  
    // abstact methods
}  

The interface can only contain abstract methods and constant fields.

An interface has to be implemented by the class and an interface has to extends an other interface.

Example program for inheritance

// interface creation
interface Language {
  public void setLanguage(String name);
  public String getLanguage();
}

// class implements interface
class JavaProgramming implements Language {
  String language= "";
  public void setLanguage(String name){
      language = name;
  }
  
  public String getLanguage(){
      return language;
  }
}

class Main {
  public static void main(String[] args) {
    JavaProgramming language = new JavaProgramming();
    language.setLanguage("Java");
    String languageName =  language.getLanguage();
    System.out.println("Language is "+languageName);
  }
}

Output

Language is Java

In the above program, we have an interface Language with 2 abstract methods setLanguage() and getLanguage().

Next, we have a class JavaProgramming which implements the Language interface. So JavaProgramming class will have to implement setLanguage() and getLanguage() methods.

Later, we create object for the JavaProgramming class and set the name of the language using setLanguage() method and get the name of the language using getLanguage().

Multiple inheritance with interface

With the help of interface we can implement the multiple inheritance since multiple inheritance is not supported in java.

Example for multiple inheritance with interface

interface Printable {
    void printPage();
}
interface Scannable {
    void scanPage();
}
class Printer implements Printable, Scannable {
    public void printPage() {
        System.out.println("Printable");
    }
    public void scanPage() {
        System.out.println("Scannable");
    }
}

class Main {

    public static void main(String args[]) {
        Printer obj = new Printer();
        obj.printPage();
        obj.scanPage();
    }
}

Output

Printable
Scannable

In the above program we have created 2 interfaces Printable and Scannable with their own abstract methods.

Next, these two interfaces are implemented by Printer class. This Printer class then implements both the printPage and scanPage methods.

Now in the Main class we create an object for the Printer class and call the printPage and scanPage methods.

Interface inheritance

It is possible to extend an interface A by an other interface B. In such case, the class that implements the interface B, has to implement the abstract methods of interface A and B.

Example program for interface inheritance

interface IScannable {
  void scanPage();
}
interface IPrinter extends IScannable {
  void printPage();
}
class Printer implements IPrinter {
  public void printPage() {
    System.out.println("Printable");
  }
  public void scanPage() {
    System.out.println("Scannable");
  }
}

class Main {

  public static void main(String args[]) {
    IPrinter obj = new Printer();
    obj.printPage();
    obj.scanPage();
  }
}

In the above program, we created an interface IScannable and this interface is extended by IPrinter interface.

Next, in the Printer class we implement the IPrinter interface. So it implements the abstract methods of IPrinter as well as IScannable.

Next, in the Main class we create an object for the Printer class and assign it to IPrinter object.

Now, using the IPrinter object we call the printPage() and scanPage() methods.

Points to remember

• Interfaces contains only the abstract methods.
• We cannot instantiate the interface.
• We can create an instance of a class that implements an interface and assign it to the object of that interface.
• Interface cannot contain function with definition.